package lpg;

import java.util.List;

class Lpgact
{
    void ruleAction(int ruleNumber)
    {
        switch(ruleNumber)
        {
        //
        // Rule 1: LPG_INPUT ::= Grammar
        //
        case 1:
        {   // Line 111 "lpg.g"
            //
            // If start symbols are specified in this source file, then
            // they override all imported start symbols, if any.
            //
            if (startIndexes.isEmpty())
            {
                //
                // If no start symbol is specified in this source file but this source
                // file contains more than one imported file with one or more start symbols
                // specified in them then it's an error.
                // If one and only one of the imported files contain start symbol
                // specification(s) then we inherit these start symbols.
                //
                int importedSize = importedStartIndexes.size();
                if (importedSize > 1)
                {
                    for (int i = 0; i < importedSize; i++)
                         option.emitError(importedStartIndexes.get(i).importFileIndex,
                                             "Conflicting start symbol(s) specified in this imported file");
                    control.exit();
                }
                else if (importedSize == 1)
                {
                    ImportedStartIndexes element = importedStartIndexes.get(0);
                    startIndexes.addAll(element.startIndexes);
                }
            }

            importedStartIndexes.clear(); // free up space.
        }
        break;

        //
        // Rule 2: Grammar ::= $Empty
        //
        case 2: break;

        //
        // Rule 3: Grammar ::= Grammar include_segment END_KEY_opt
        //
        case 3: break;

        //
        // Rule 4: Grammar ::= Grammar notice_segment END_KEY_opt
        //
        case 4: break;

        //
        // Rule 5: Grammar ::= Grammar define_segment END_KEY_opt
        //
        case 5: break;

        //
        // Rule 6: Grammar ::= Grammar terminals_segment END_KEY_opt
        //
        case 6: break;

        //
        // Rule 7: Grammar ::= Grammar export_segment END_KEY_opt
        //
        case 7: break;

        //
        // Rule 8: Grammar ::= Grammar import_segment END_KEY_opt
        //
        case 8: break;

        //
        // Rule 9: Grammar ::= Grammar softkeywords_segment END_KEY_opt
        //
        case 9: break;

        //
        // Rule 10: Grammar ::= Grammar eof_segment END_KEY_opt
        //
        case 10: break;

        //
        // Rule 11: Grammar ::= Grammar eol_segment END_KEY_opt
        //
        case 11: break;

        //
        // Rule 12: Grammar ::= Grammar error_segment END_KEY_opt
        //
        case 12: break;

        //
        // Rule 13: Grammar ::= Grammar prostheses_segment END_KEY_opt
        //
        case 13: break;

        //
        // Rule 14: Grammar ::= Grammar recover_segment END_KEY_opt
        //
        case 14: break;

        //
        // Rule 15: Grammar ::= Grammar identifier_segment END_KEY_opt
        //
        case 15: break;

        //
        // Rule 16: Grammar ::= Grammar start_segment END_KEY_opt
        //
        case 16: break;

        //
        // Rule 17: Grammar ::= Grammar alias_segment END_KEY_opt
        //
        case 17: break;

        //
        // Rule 18: Grammar ::= Grammar names_segment END_KEY_opt
        //
        case 18: break;

        //
        // Rule 19: Grammar ::= Grammar headers_segment END_KEY_opt
        //
        case 19: break;

        //
        // Rule 20: Grammar ::= Grammar ast_segment END_KEY_opt
        //
        case 20: break;

        //
        // Rule 21: Grammar ::= Grammar globals_segment END_KEY_opt
        //
        case 21: break;

        //
        // Rule 22: Grammar ::= Grammar trailers_segment END_KEY_opt
        //
        case 22: break;

        //
        // Rule 23: Grammar ::= Grammar rules_segment END_KEY_opt
        //
        case 23: break;

        //
        // Rule 24: Grammar ::= Grammar types_segment END_KEY_opt
        //
        case 24: break;

        //
        // Rule 25: Grammar ::= Grammar dps_segment END_KEY_opt
        //
        case 25: break;

        //
        // Rule 26: include_segment ::= INCLUDE_KEY
        //
        case 26: break;

        //
        // Rule 27: include_segment ::= INCLUDE_KEY SYMBOL
        //
        case 27: break;

        //
        // Rule 28: notice_segment ::= NOTICE_KEY
        //
        case 28: break;

        //
        // Rule 29: notice_segment ::= notice_segment action_segment
        //
        case 29:
        {   // Line 225 "lpg.g"
            noticeBlocks.add(getToken(2));
        }
        break;

        //
        // Rule 30: define_segment ::= DEFINE_KEY
        //
        case 30: break;

        //
        // Rule 31: define_segment ::= define_segment macro_name_symbol macro_segment
        //
        case 31:
        {   // Line 233 "lpg.g"
            MacroSymbol macroSymbol = lexStream.getMacroSymbol(getToken(2));
            assert (macroSymbol != null);
            macroSymbol.setBlock(getToken(3));
        }
        break;

        //
        // Rule 32: macro_name_symbol ::= MACRO_NAME
        //
        case 32: break;

        //
        // Rule 33: macro_name_symbol ::= SYMBOL
        //
        case 33:
        {   // Line 243 "lpg.g"
            int token1 = getToken(1);
            String macroName = option.escape + lexStream.nameString(token1);
            MacroSymbol macroSymbol = macroTable.find(macroName);
            if (macroSymbol == null)
            {
                macroSymbol = new MacroSymbol(macroName, macroTable.size());
                macroTable.insert(macroName, macroSymbol);
                option.emitWarning(token1, Parser.ActError.MACRO_EXPECTED_INSTEAD_OF_SYMBOL.msg);
            }

            lexStream.getTokenReference(token1).setSymbol(macroSymbol);
        }
        break;

        //
        // Rule 34: macro_segment ::= BLOCK
        //
        case 34: break;

        //
        // Rule 35: terminals_segment ::= TERMINALS_KEY
        //
        case 35: break;

        //
        // Rule 36: terminals_segment ::= terminals_segment terminal_symbol
        //
        case 36:
        {   // Line 264 "lpg.g"
            terminals.add(getToken(2));
        }
        break;

        //
        // Rule 37: terminals_segment ::= terminals_segment terminal_symbol produces name
        //
        case 37:
        {   // Line 269 "lpg.g"
            int token2 = getToken(2);
            int token4 = getToken(4);
            terminals.add(token2);
            names.add(new NameDefinition(token2, token4));
            aliases.add(new AliasDefinition(token4, token2));
        }
        break;

        //
        // Rule 38: export_segment ::= EXPORT_KEY
        //
        case 38: break;

        //
        // Rule 39: export_segment ::= export_segment terminal_symbol
        //
        case 39:
        {   // Line 281 "lpg.g"
            exports.add(getToken(2));
        }
        break;

        //
        // Rule 40: import_segment ::= IMPORT_KEY
        //
        case 40: break;

        //
        // Rule 41: import_segment ::= IMPORT_KEY SYMBOL {drop_command}
        //
        case 41:
        {   // Line 289 "lpg.g"
            int currentIndex = lexStream.peek();
            int startIndex = lexStream.numTokens();
            int token2 = getToken(2);

            Scanner scanner = new Scanner(option, lexStream, variableTable, macroTable);
            scanner.scanFile(token2);

            if (scanner.numErrorTokens() > 0)
                control.exit();
            else // file found and scanned with no errors?
            {
                //
                // If the file is already in the process of being included, issue an error and stop.
                //
                InputFileSymbol importFile = lexStream.findOrInsertFile(
                        option.includeSearchDirectory, lexStream.nameString(token2));
                assert (importFile != null);

                if (importFile.isLocked())
                {
                    option.emitWarning(token2, Parser.ActError.RECURSIVE_IMPORT.msg);
                    control.exit();
                }
                else
                {
                    //
                    // Lock the include_file to avoid looping...
                    //
                    importFile.lock();

                    Parser parser = new Parser(control, lexStream, variableTable, macroTable);
                    parser.parse(startIndex);

                    this.parser.merge(token2, parser);

                    importFile.unlock();
                }
            }

            droppedRules.clear();
            lexStream.reset(currentIndex);
        }
        break;

        //
        // Rule 42: drop_command ::= drop_symbols
        //
        case 42: break;

        //
        // Rule 43: drop_command ::= drop_rules
        //
        case 43: break;

        //
        // Rule 44: drop_command ::= DROPACTIONS_KEY
        //
        case 44: break;

        //
        // Rule 45: drop_symbols ::= DROPSYMBOLS_KEY
        //
        case 45: break;

        //
        // Rule 46: drop_symbols ::= drop_symbols SYMBOL
        //
        case 46:
        {   // Line 349 "lpg.g"
            droppedRules.add(new RuleDefinition(getToken(2), 0, 0));
        }
        break;

        //
        // Rule 47: drop_rules ::= DROPRULES_KEY
        //
        case 47: break;

        //
        // Rule 48: drop_rules ::= drop_rules drop_rule
        //
        case 48: break;

        //
        // Rule 49: drop_rule ::= SYMBOL produces rhs
        //
        case 49:
        {   // Line 360 "lpg.g"
            droppedRules.add(new RuleDefinition(getToken(1), getToken(2), parser.curTok));
        }
        break;

        //
        // Rule 50: drop_rule ::= SYMBOL MACRO_NAME produces rhs
        //
        case 50:
        {   // Line 365 "lpg.g"
            droppedRules.add(new RuleDefinition(getToken(1), getToken(3), parser.curTok));
        }
        break;

        //
        // Rule 51: drop_rule ::= drop_rule | rhs
        //
        case 51:
        {   // Line 370 "lpg.g"
            RuleDefinition rule = droppedRules.get(droppedRules.size() - 1);
            droppedRules.add(new RuleDefinition(rule.lhsIndex, getToken(2), parser.curTok));
        }
        break;

        //
        // Rule 52: {drop_command} ::= $Empty
        //
        case 52: break;

        //
        // Rule 53: {drop_command} ::= {drop_command} drop_command
        //
        case 53: break;

        //
        // Rule 54: softkeywords_segment ::= SOFTKEYWORDS_KEY
        //
        case 54: break;

        //
        // Rule 55: softkeywords_segment ::= softkeywords_segment terminal_symbol
        //
        case 55:
        {   // Line 385 "lpg.g"
            keywords.add(getToken(2));
        }
        break;

        //
        // Rule 56: softkeywords_segment ::= softkeywords_segment terminal_symbol produces name
        //
        case 56:
        {   // Line 390 "lpg.g"
            int token2 = getToken(2);
            int token4 = getToken(4);
            keywords.add(token2);
            names.add(new NameDefinition(token2, token4));
            aliases.add(new AliasDefinition(token4, token2));
        }
        break;

        //
        // Rule 57: error_segment ::= ERROR_KEY
        //
        case 57: break;

        //
        // Rule 58: error_segment ::= ERROR_KEY terminal_symbol
        //
        case 58:
        {   // Line 402 "lpg.g"
            parser.setErrorIndex(getToken(2));
        }
        break;

        //
        // Rule 59: prostheses_segment ::= PROSTHESES_KEY
        //
        case 59: break;

        //
        // Rule 60: prostheses_segment ::= prostheses_segment prosthesis
        //
        case 60: break;

        //
        // Rule 61: prosthesis ::= SYMBOL action_segment_opt
        //
        case 61:
        {   // Line 413 "lpg.g"
            // Set separatorIndex to curTok to facilitate (null) iteration over the rhs
            prostheses.add(new RuleDefinition(getToken(1), parser.curTok, parser.curTok));
        }
        break;

        //
        // Rule 62: prosthesis ::= SYMBOL MACRO_NAME action_segment_opt
        //
        case 62:
        {   // Line 419 "lpg.g"
            // Set separatorIndex to curTok to facilitate (null) iteration over the rhs
            prostheses.add(new RuleDefinition(getToken(1), parser.curTok, parser.curTok, getToken(2), 0));
        }
        break;

        //
        // Rule 63: prosthesis ::= SYMBOL MACRO_NAME MACRO_NAME action_segment_opt
        //
        case 63:
        {   // Line 425 "lpg.g"
            parser.addVariableName(getToken(3));

            // Set separatorIndex to curTok to facilitate (null) iteration over the rhs
            prostheses.add(new RuleDefinition(getToken(1), parser.curTok, parser.curTok, getToken(2), getToken(3)));
        }
        break;

        //
        // Rule 64: action_segment_opt ::= $Empty
        //
        case 64: break;

        //
        // Rule 65: action_segment_opt ::= action_segment
        //
        case 65: break;

        //
        // Rule 66: recover_segment ::= RECOVER_KEY
        //
        case 66: break;

        //
        // Rule 67: recover_segment ::= recover_segment terminal_symbol
        //
        case 67:
        {   // Line 442 "lpg.g"
            recovers.add(getToken(2));
        }
        break;

        //
        // Rule 68: identifier_segment ::= IDENTIFIER_KEY
        //
        case 68: break;

        //
        // Rule 69: identifier_segment ::= IDENTIFIER_KEY terminal_symbol
        //
        case 69:
        {   // Line 450 "lpg.g"
            parser.setIdentifierIndex(getToken(2));
        }
        break;

        //
        // Rule 70: eol_segment ::= EOL_KEY
        //
        case 70: break;

        //
        // Rule 71: eol_segment ::= EOL_KEY terminal_symbol
        //
        case 71:
        {   // Line 458 "lpg.g"
            parser.setEolIndex(getToken(2));
        }
        break;

        //
        // Rule 72: eof_segment ::= EOF_KEY
        //
        case 72: break;

        //
        // Rule 73: eof_segment ::= EOF_KEY terminal_symbol
        //
        case 73:
        {   // Line 466 "lpg.g"
            parser.setEofIndex(getToken(2));
        }
        break;

        //
        // Rule 74: terminal_symbol ::= SYMBOL
        //
        case 74: break;

        //
        // Rule 75: terminal_symbol ::= MACRO_NAME
        //
        case 75:
        {   // Line 474 "lpg.g"
            parser.changeMacroToVariable(getToken(1));
        }
        break;

        //
        // Rule 76: alias_segment ::= ALIAS_KEY
        //
        case 76: break;

        //
        // Rule 77: alias_segment ::= alias_segment ERROR_KEY produces alias_rhs
        //
        case 77:
        {   // Line 482 "lpg.g"
            parser.setErrorIndex(getToken(4));
        }
        break;

        //
        // Rule 78: alias_segment ::= alias_segment EOL_KEY produces alias_rhs
        //
        case 78:
        {   // Line 487 "lpg.g"
            parser.setEolIndex(getToken(4));
        }
        break;

        //
        // Rule 79: alias_segment ::= alias_segment EOF_KEY produces alias_rhs
        //
        case 79:
        {   // Line 492 "lpg.g"
            parser.setEofIndex(getToken(4));
        }
        break;

        //
        // Rule 80: alias_segment ::= alias_segment IDENTIFIER_KEY produces alias_rhs
        //
        case 80:
        {   // Line 497 "lpg.g"
            parser.setIdentifierIndex(getToken(4));
        }
        break;

        //
        // Rule 81: alias_segment ::= alias_segment SYMBOL produces alias_rhs
        //
        case 81:
        {   // Line 502 "lpg.g"
            aliases.add(new AliasDefinition(getToken(2), getToken(4)));
        }
        break;

        //
        // Rule 82: alias_segment ::= alias_segment alias_lhs_macro_name produces alias_rhs
        //
        case 82:
        {   // Line 507 "lpg.g"
            aliases.add(new AliasDefinition(getToken(2), getToken(4)));
        }
        break;

        //
        // Rule 83: alias_lhs_macro_name ::= MACRO_NAME
        //
        case 83:
        {   // Line 512 "lpg.g"
            parser.changeMacroToVariable(getToken(1));
        }
        break;

        //
        // Rule 84: alias_rhs ::= SYMBOL
        //
        case 84: break;

        //
        // Rule 85: alias_rhs ::= MACRO_NAME
        //
        case 85:
        {   // Line 520 "lpg.g"
            parser.changeMacroToVariable(getToken(1));
        }
        break;

        //
        // Rule 86: alias_rhs ::= ERROR_KEY
        //
        case 86: break;

        //
        // Rule 87: alias_rhs ::= EOL_KEY
        //
        case 87: break;

        //
        // Rule 88: alias_rhs ::= EOF_KEY
        //
        case 88: break;

        //
        // Rule 89: alias_rhs ::= EMPTY_KEY
        //
        case 89: break;

        //
        // Rule 90: alias_rhs ::= IDENTIFIER_KEY
        //
        case 90: break;

        //
        // Rule 91: start_segment ::= START_KEY
        //
        case 91: break;

        //
        // Rule 92: start_segment ::= start_segment start_symbol
        //
        case 92:
        {   // Line 543 "lpg.g"
            startIndexes.add(getToken(2));
        }
        break;

        //
        // Rule 93: headers_segment ::= HEADERS_KEY
        //
        case 93: break;

        //
        // Rule 94: headers_segment ::= headers_segment action_segment
        //
        case 94:
        {   // Line 551 "lpg.g"
            headerBlocks.add(getToken(2));
        }
        break;

        //
        // Rule 95: ast_segment ::= AST_KEY
        //
        case 95: break;

        //
        // Rule 96: ast_segment ::= ast_segment action_segment
        //
        case 96:
        {   // Line 559 "lpg.g"
            astBlocks.add(getToken(2));
        }
        break;

        //
        // Rule 97: globals_segment ::= GLOBALS_KEY
        //
        case 97: break;

        //
        // Rule 98: globals_segment ::= globals_segment action_segment
        //
        case 98:
        {   // Line 567 "lpg.g"
            globalBlocks.add(getToken(2));
        }
        break;

        //
        // Rule 99: trailers_segment ::= TRAILERS_KEY
        //
        case 99: break;

        //
        // Rule 100: trailers_segment ::= trailers_segment action_segment
        //
        case 100:
        {   // Line 575 "lpg.g"
            trailerBlocks.add(getToken(2));
        }
        break;

        //
        // Rule 101: start_symbol ::= SYMBOL
        //
        case 101: break;

        //
        // Rule 102: start_symbol ::= MACRO_NAME
        //
        case 102: break;

        //
        // Rule 103: rules_segment ::= RULES_KEY {action_segment}
        //
        case 103: break;

        //
        // Rule 104: rules_segment ::= rules_segment rules
        //
        case 104: break;

        //
        // Rule 105: rules ::= SYMBOL produces rhs
        //
        case 105:
        {   // Line 592 "lpg.g"
            rules.add(new RuleDefinition(getToken(1), getToken(2), parser.curTok));
        }
        break;

        //
        // Rule 106: rules ::= SYMBOL MACRO_NAME produces rhs
        //
        case 106:
        {   // Line 597 "lpg.g"
            rules.add(new RuleDefinition(getToken(1), getToken(3), parser.curTok, getToken(2), 0));
        }
        break;

        //
        // Rule 107: rules ::= SYMBOL MACRO_NAME MACRO_NAME produces rhs
        //
        case 107:
        {   // Line 602 "lpg.g"
            parser.addVariableName(getToken(3));

            rules.add(new RuleDefinition(getToken(1), getToken(4), parser.curTok, getToken(2), getToken(3)));
        }
        break;

        //
        // Rule 108: rules ::= rules | rhs
        //
        case 108:
        {   // Line 609 "lpg.g"
            RuleDefinition rule = rules.get(rules.size() - 1);
            rules.add(new RuleDefinition(rule.lhsIndex, getToken(2),
                    parser.curTok, rule.classnameIndex, rule.arrayElementTypeIndex));
        }
        break;

        //
        // Rule 109: produces ::= ::=
        //
        case 109: break;

        //
        // Rule 110: produces ::= ::=?
        //
        case 110: break;

        //
        // Rule 111: produces ::= ->
        //
        case 111: break;

        //
        // Rule 112: produces ::= ->?
        //
        case 112: break;

        //
        // Rule 113: rhs ::= $Empty
        //
        case 113: break;

        //
        // Rule 114: rhs ::= rhs SYMBOL
        //
        case 114: break;

        //
        // Rule 115: rhs ::= rhs SYMBOL MACRO_NAME
        //
        case 115: break;

        //
        // Rule 116: rhs ::= rhs EMPTY_KEY
        //
        case 116: break;

        //
        // Rule 117: rhs ::= rhs action_segment
        //
        case 117: break;

        //
        // Rule 118: action_segment ::= BLOCK
        //
        case 118: break;

        //
        // Rule 119: types_segment ::= TYPES_KEY
        //
        case 119: break;

        //
        // Rule 120: types_segment ::= types_segment type_declarationlist
        //
        case 120: break;

        //
        // Rule 121: type_declarationlist ::= type_declarations
        //
        case 121: break;

        //
        // Rule 122: type_declarationlist ::= type_declarations BLOCK
        //
        case 122:
        {   // Line 654 "lpg.g"
            int index = types.size();
            do
            {
                types.get(--index).blockIndex = getToken(2);
            }
            while(lexStream.kind(types.get(index).separatorIndex) == Lpgsym.TK_OR_MARKER);
        }
        break;

        //
        // Rule 123: type_declarations ::= SYMBOL produces SYMBOL
        //
        case 123:
        {   // Line 664 "lpg.g"
            types.add(new TypeDefinition(getToken(1), getToken(2), getToken(3), 0));
        }
        break;

        //
        // Rule 124: type_declarations ::= type_declarations | SYMBOL
        //
        case 124:
        {   // Line 668 "lpg.g"
            TypeDefinition type = types.get(types.size() - 1);
            types.add(new TypeDefinition(type.typeIndex, getToken(2), getToken(3), 0));
        }
        break;

        //
        // Rule 125: dps_segment ::= DISJOINTPREDECESSORSETS_KEY
        //
        case 125: break;

        //
        // Rule 126: dps_segment ::= dps_segment SYMBOL SYMBOL
        //
        case 126:
        {   // Line 677 "lpg.g"
            predecessorCandidates.add(new PredecessorSetDefinition(getToken(2), getToken(3)));
        }
        break;

        //
        // Rule 127: names_segment ::= NAMES_KEY
        //
        case 127: break;

        //
        // Rule 128: names_segment ::= names_segment name produces name
        //
        case 128:
        {   // Line 685 "lpg.g"
            names.add(new NameDefinition(getToken(2), getToken(4)));
        }
        break;

        //
        // Rule 129: name ::= SYMBOL
        //
        case 129: break;

        //
        // Rule 130: name ::= MACRO_NAME
        //
        case 130:
        {   // Line 693 "lpg.g"
            parser.changeMacroToVariable(getToken(1));
        }
        break;

        //
        // Rule 131: name ::= EMPTY_KEY
        //
        case 131:
        {   // Line 698 "lpg.g"
            option.emitError(getToken(1), "Illegal use of empty name or empty keyword");
            control.exit();
        }
        break;

        //
        // Rule 132: name ::= ERROR_KEY
        //
        case 132: break;

        //
        // Rule 133: name ::= EOL_KEY
        //
        case 133: break;

        //
        // Rule 134: name ::= IDENTIFIER_KEY
        //
        case 134: break;

        //
        // Rule 135: END_KEY_opt ::= $Empty
        //
        case 135: break;

        //
        // Rule 136: END_KEY_opt ::= END_KEY
        //
        case 136: break;

        //
        // Rule 137: {action_segment} ::= $Empty
        //
        case 137: break;

        //
        // Rule 138: {action_segment} ::= {action_segment} action_segment
        //
        case 138:
        {   // Line 722 "lpg.g"
            initialBlocks.add(getToken(2));
        }
        break;

        default:
            assert false;
        }
    }

    Lpgact(Parser parser)
    {
        this.parser                 = parser;
        this.control                = parser.control;
        this.option                 = parser.option;
        this.lexStream              = parser.lexStream;
        this.variableTable          = parser.variableTable;
        this.macroTable             = parser.macroTable;
        this.terminals              = parser.terminals;
        this.keywords               = parser.keywords;
        this.exports                = parser.exports;
        this.recovers               = parser.recovers;
        this.startIndexes           = parser.startIndexes;
        this.predecessorCandidates  = parser.predecessorCandidates;
        this.aliases                = parser.aliases;
        this.names                  = parser.names;
        this.noticeBlocks           = parser.noticeBlocks;
        this.globalBlocks           = parser.globalBlocks;
        this.astBlocks              = parser.astBlocks;
        this.headerBlocks           = parser.headerBlocks;
        this.initialBlocks          = parser.initialBlocks;
        this.trailerBlocks          = parser.trailerBlocks;
        this.rules                  = parser.rules;
        this.droppedRules           = parser.droppedRules;
        this.prostheses             = parser.prostheses;
        this.types                  = parser.types;
        this.importedStartIndexes   = parser.importedStartIndexes;
    }

    private int getToken(int i)
    {
        return parser.getToken(i);
    }

    private final Parser parser;
    private final Control control;
    private final Option option;
    private final LexStream lexStream;
    private final LookupTable<String, VariableSymbol> variableTable;
    private final LookupTable<String, MacroSymbol> macroTable;
    private final IntArrayList terminals;
    private final IntArrayList keywords;
    private final IntArrayList exports;
    private final IntArrayList recovers;
    private final IntArrayList startIndexes;
    private final List<PredecessorSetDefinition> predecessorCandidates;
    private final List<AliasDefinition> aliases;
    private final List<NameDefinition> names;
    private final IntArrayList noticeBlocks;
    private final IntArrayList globalBlocks;
    private final IntArrayList astBlocks;
    private final IntArrayList headerBlocks;
    private final IntArrayList initialBlocks;
    private final IntArrayList trailerBlocks;
    private final List<RuleDefinition> rules;
    private final List<RuleDefinition> droppedRules;
    private final List<RuleDefinition> prostheses;
    private final List<TypeDefinition> types;
    private final List<ImportedStartIndexes> importedStartIndexes;

}
